FEXPCalculationResult.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// Results of a numerical simulation
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPCALCULATIONRESULT_H_
#define _CFEXPCALCULATIONRESULT_H_
#include "FEXPCommon.h"
#include "FEXPSerializeDataTables.h"
#include "FEXPDataContainer.h"


struct CFEXPNodeResultData
{
  size_t          _model_id;     size_t          _node_id;
  size_t          _time_counter; t_fexpcommon_ct _time;
  t_fexpcommon_ct _cx;           t_fexpcommon_ct _cy;      t_fexpcommon_ct _cz;
  t_fexpcommon_ct _ux;           t_fexpcommon_ct _uy;      t_fexpcommon_ct _uz;
  t_fexpcommon_ct _fix;          t_fexpcommon_ct _fiy;     t_fexpcommon_ct _fiz;
  t_fexpcommon_ct _epsx;         t_fexpcommon_ct _epsy;    t_fexpcommon_ct _epsxy;
  t_fexpcommon_ct _sigx;         t_fexpcommon_ct _sigy;    t_fexpcommon_ct _sigxy;
  static std::string GetDefOrder()
  {
    std::string tabdef = FEXPCOMMON_EMPTY_STRING;
    tabdef += "model_id"     + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "node_id"      + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "time_counter" + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "time"         + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "cx"           + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "cy"           + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "cz"           + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "ux"           + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "uy"           + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "uz"           + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "fix"          + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "fiy"          + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "fiz"          + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "epsx"         + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "epsy"         + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "epsxy"        + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "sigx"         + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "sigy"         + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "sigxy";
    return tabdef;
  }

  std::string GetSerializedData()
  {
    std::string data = FEXPCOMMON_EMPTY_STRING;
    data += CFEXPBaseConvers::NumberToString(_model_id    ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_node_id     ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_time_counter) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_time        ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_cx          ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_cy          ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_cz          ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_ux          ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_uy          ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_uz          ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_fix         ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_fiy         ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_fiz         ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_epsx        ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_epsy        ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_epsxy       ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_sigx        ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_sigy        ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_sigxy       );
    return data;
  }
};


struct CFEXPResultElementConnect
{
  size_t _model_id;     size_t          _fe_id;
  size_t _time_counter; t_fexpcommon_ct _time;
  size_t _node1_id;     size_t          _node2_id; size_t _node3_id;
  static std::string GetDefOrder()
  {
    std::string tabdef = FEXPCOMMON_EMPTY_STRING;
    tabdef += "model_id"     + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "fe_id"        + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "time_counter" + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "time"         + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "node1_id"     + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "node2_id"     + std::string(FEXPCOMMON_DELIMITER);
    tabdef += "node3_id";
    return tabdef;
  }

  std::string GetSerializedData()
  {
    std::string data = FEXPCOMMON_EMPTY_STRING;
    data += CFEXPBaseConvers::NumberToString(_model_id    ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_fe_id       ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_time_counter) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_time        ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_node1_id    ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_node2_id    ) + FEXPCOMMON_DELIMITER;
    data += CFEXPBaseConvers::NumberToString(_node3_id    );
    return data;
  }
};


class CFEXPCalculationModelNodeResult
  : public ICFEXPModelDataIntf
{
public:
  CFEXPCalculationModelNodeResult(size_t time_id);
  virtual ~CFEXPCalculationModelNodeResult() { }
  
  // override pure virtual member function
  virtual size_t GetId          ()          override { return _result_time_id;                     }
  virtual size_t GetType        ()          override { return size_t(ESystemElementType::eResult); }
  virtual size_t GetModelId     ()          override { FEXPCOMMON_NOT_IMPLEMENTED_EX;              }
  virtual size_t GetThreadId    ()          override { FEXPCOMMON_NOT_IMPLEMENTED_EX;              }
  virtual size_t GetThreadNumber()          override { FEXPCOMMON_NOT_IMPLEMENTED_EX;              }
  virtual void   SetThreadId    (size_t id) override { FEXPCOMMON_NOT_IMPLEMENTED_EX;              }
  // serialization -- not implemented
  virtual Ptr<t_SerializedData> NetSerialize  ()                            override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }
  virtual void                  NetDeserialize(Ptr<t_SerializedData> data)  override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }

  void AddNewTimeResult(Ptr<CFEXPCalculationResTable_NODE_RES        > results);
  void AddNewTimeResult(Ptr<CFEXPCalculationResTable_FE_CONNECT      > connect);
  void AddNewTimeResult(Ptr<CFEXPCalculationResTable_NODE_RES::Data  > results);
  void AddNewTimeResult(Ptr<CFEXPCalculationResTable_FE_CONNECT::Data> connect);
  template<typename TType>
  void AddNewTimeResult(Ptr<std::map<std::string, std::string>> res_map);
  void ClearData    () { _time_node_results.clear(); _fe_connectivity.clear(); }
  // current results
  std::vector<Ptr<CFEXPNodeResultData      >> & GetNodeResults () { return _time_node_results; }
  std::vector<Ptr<CFEXPResultElementConnect>> & GetConnectivity() { return _fe_connectivity;   }
protected:
  // [no protected members] -----------------------------
private:
  size_t _result_time_id;
  std::vector<Ptr<CFEXPNodeResultData      >> _time_node_results;
  std::vector<Ptr<CFEXPResultElementConnect>> _fe_connectivity;
};

//--------------------------------------------------------------------------------------
template<typename TType>
void CFEXPCalculationModelNodeResult::AddNewTimeResult(Ptr<std::map<std::string, std::string>> res_map)
//--------------------------------------------------------------------------------------
{
  if (std::is_same<TType, CFEXPNodeResultData>::value)
  {
    auto data = CFEXPDataManager<CFEXPNodeResultData>::SafeAllocInstance();
    data->_model_id     = CFEXPBaseConvers::StringToNumber<size_t>         (res_map->at("model_id"    ));
    data->_node_id      = CFEXPBaseConvers::StringToNumber<size_t>         (res_map->at("node_id"     ));
    data->_time_counter = CFEXPBaseConvers::StringToNumber<size_t>         (res_map->at("time_counter"));
    data->_time         = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("time"        ));
    data->_cx           = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("cx"          ));
    data->_cy           = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("cy"          ));
    data->_cz           = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("cz"          ));
    data->_ux           = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("ux"          ));
    data->_uy           = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("uy"          ));
    data->_uz           = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("uz"          ));
    data->_fix          = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("fix"         ));
    data->_fiy          = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("fiy"         ));
    data->_fiz          = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("fiz"         ));
    data->_epsx         = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("epsx"        ));
    data->_epsy         = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("epsy"        ));
    data->_epsxy        = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("epsxy"       ));
    data->_sigx         = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("sigx"        ));
    data->_sigy         = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("sigy"        ));
    data->_sigxy        = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("sigxy"       ));
    _time_node_results.push_back(data);
    return;
  }

  if (std::is_same<TType, CFEXPResultElementConnect>::value)
  {
    auto data = CFEXPDataManager<CFEXPResultElementConnect>::SafeAllocInstance();
    data->_model_id     = CFEXPBaseConvers::StringToNumber<size_t>         (res_map->at("model_id"    ));
    data->_fe_id        = CFEXPBaseConvers::StringToNumber<size_t>         (res_map->at("fe_id"       ));
    data->_time_counter = CFEXPBaseConvers::StringToNumber<size_t>         (res_map->at("time_counter"));
    data->_time         = CFEXPBaseConvers::StringToNumber<t_fexpcommon_ct>(res_map->at("time"        ));
    data->_node1_id     = CFEXPBaseConvers::StringToNumber<size_t>         (res_map->at("node1_id"    ));
    data->_node2_id     = CFEXPBaseConvers::StringToNumber<size_t>         (res_map->at("node2_id"    ));
    data->_node3_id     = CFEXPBaseConvers::StringToNumber<size_t>         (res_map->at("node3_id"    ));
    _fe_connectivity.push_back(data);
    return;
  }
  FEXPCOMMON_EXCEPTION("Error: Wrong result template parameter!!!");
}

#endif // !_CFEXPCALCULATIONRESULT_H_